home *** CD-ROM | disk | FTP | other *** search
/ Aminet 50 / Aminet 50 (2002)(GTI - Schatztruhe)[!][Aug 2002].iso / Aminet / text / edit / tecoc-146.lha / cmatch.c < prev    next >
C/C++ Source or Header  |  1991-07-05  |  7KB  |  309 lines
  1. /*****************************************************************************
  2.  
  3.     CMatch()
  4.  
  5.     This recursive function trys to match one match construct with the
  6. character pointed to by EBPtr2.  It sets SamChr, which indicates whether the
  7. match was successful or not.  SStPtr is left pointing to the last character
  8. of the match construct.
  9.     If the match construct is ^Em or ^S,  then EBPtr2 will be updated to
  10. point to the last matched character.  In this case,  RhtSid is needed to
  11. indicate the limit past which EBPtr2 should not be incremented.
  12.  
  13.     Match constructs are:
  14.  
  15.     ^X        match any character
  16.     ^S        match a separator character (not letter or digit)
  17.     ^N        match anything but following match construct
  18.     ^EA        match any alphabetic
  19.     ^EB        match a separator character (not letter or digit)
  20.     ^EC        match symbol constituent
  21.     ^ED        match any digit
  22.     ^EGq        match any character in q-register q
  23.     ^EL        match any line terminator (LF, VT, FF)
  24.     ^EM        match non-null string of following match construct
  25.     ^ER        match any alphanumeric
  26.     ^ES        match non-null string of spaces and/or tabs
  27.     ^EV        match lowercase alphabetic
  28.     ^EW        match uppercase alphabetic
  29.     ^EX        match any character
  30.     ^E<nnn>        match character with ASCII code nnn (octal)
  31.     ^E[x1,x2,...xn]    match any of the match constructs x1, x2, etc.
  32.     else        match the character itself
  33.  
  34. *****************************************************************************/
  35.  
  36. #include "zport.h"        /* define portability identifiers */
  37. #include "tecoc.h"        /* define general identifiers */
  38. #include "defext.h"        /* define external global variables */
  39. #include "dchars.h"        /* define identifiers for characters */
  40. #include "chmacs.h"        /* define character processing macros */
  41. #include "deferr.h"        /* define identifiers for error messages */
  42.  
  43. DEFAULT CMatch(SamChr)        /* match a character */
  44. BOOLEAN *SamChr;        /* returned match indicator */
  45. {
  46.     BOOLEAN    ChrMat;        /* character match indicator */
  47.     char    OtCase;        /* "other" case character */
  48.     charptr    QRPtr;        /* pointer into q-register text */
  49.     charptr    SavEP2;        /* temporary holder of EBPtr2 */
  50.     charptr    SavSSP;        /* temporary holder of SStPtr */
  51.     DEFAULT    Status;        /* FindQR() status for ^EGq */
  52.     charptr    TCBfPt;        /* temporary holder of CBfPtr */
  53.     charptr    TCStEn;        /* temporary holder of CStEnd */
  54.     unsigned int TmpChr;    /* accumulator for ^E<nnn> */
  55.  
  56. #if DEBUGGING
  57.     static char *DbgFNm = "CMatch";
  58.     sprintf(DbgSBf,"*SStPtr = '%c', *EBPtr2 = '%c'", *SStPtr, *EBPtr2);
  59.     DbgFEn(3,DbgFNm,DbgSBf);
  60. #endif
  61.  
  62.     switch (*SStPtr) {
  63.     case CTRL_X:
  64.     *SamChr = TRUE;
  65.     break;
  66.  
  67.     case CTRL_S:
  68.     *SamChr = !Is_Alnum(*EBPtr2);
  69.     break;
  70.  
  71.     case CTRL_N:
  72.     if (++SStPtr == SBfPtr) {
  73.         ErrMsg(ERR_ISS);        /* ill. search str. */
  74.         DBGFEX(3,DbgFNm,"FAILURE");
  75.         return FAILURE;
  76.     }
  77.     if (CMatch(&ChrMat) == FAILURE) {
  78.         DBGFEX(3,DbgFNm,"FAILURE");
  79.         return FAILURE;
  80.     }
  81.     *SamChr = !ChrMat;
  82. #if DEBUGGING
  83.     sprintf(DbgSBf,"SUCCESS, *SamChr = %s",
  84.         (*SamChr == TRUE) ? "TRUE" : "FALSE");
  85.     DbgFEx(3,DbgFNm,DbgSBf);
  86. #endif
  87.     return SUCCESS;
  88.  
  89.     case CTRL_E:
  90.     if (++SStPtr == SBfPtr) {
  91.         ErrMsg(ERR_ICE);        /* ICE = illegal ^E */
  92.         DBGFEX(3,DbgFNm,"FAILURE");
  93.         return FAILURE;
  94.     }
  95.     switch (To_Upper(*SStPtr)) {
  96.     case 'A':
  97.         *SamChr = Is_Alpha(*EBPtr2);
  98.         break;
  99.  
  100.     case 'B':
  101.         *SamChr = !Is_Alnum(*EBPtr2);
  102.         break;
  103.  
  104.     case 'C':
  105.         *SamChr = Is_SyCon(*EBPtr2);
  106.         break;
  107.  
  108.     case 'D':
  109.         *SamChr = Is_Digit(*EBPtr2);
  110.         break;
  111.  
  112.     case 'G':
  113.         if (++SStPtr == SBfPtr) {
  114.         ErrMsg(ERR_ICE); /* ill. ^E command */
  115.         DBGFEX(3,DbgFNm,"FAILURE");
  116.         return FAILURE;
  117.         }
  118.         TCBfPt = CBfPtr;    /* save CBfPtr */
  119.         TCStEn = CStEnd;    /* save CStEnd */
  120.         CBfPtr = SStPtr;
  121.         CStEnd = SBfPtr;
  122.         Status = FindQR();
  123.         SStPtr = CBfPtr;
  124.         SBfPtr = CStEnd;
  125.         CBfPtr = TCBfPt;    /* restore CBfPtr */
  126.         CStEnd = TCStEn;    /* restore CStEnd */
  127.         if (Status == FAILURE) {
  128.         DBGFEX(3,DbgFNm,"FAILURE");
  129.         return FAILURE;
  130.         }
  131.         QRPtr = QR->Start;
  132.         while (QRPtr < QR->End_P1) {
  133.         if (*QRPtr++ == *EBPtr2) {
  134.             *SamChr = TRUE;
  135. #if DEBUGGING
  136.             sprintf(DbgSBf,"SUCCESS, *SamChr = %s", (*SamChr)?"TRUE":"FALSE");
  137.             DbgFEx(3,DbgFNm,DbgSBf);
  138. #endif
  139.             return SUCCESS;
  140.         }
  141.         }
  142.         *SamChr = FALSE;
  143.         break;
  144.  
  145.     case 'L':
  146.         *SamChr = IsEOL(*EBPtr2);
  147.         break;
  148.  
  149.     case 'M':
  150.         if (++SStPtr == SBfPtr) {
  151.         ErrMsg(ERR_ICE);
  152.         DBGFEX(3,DbgFNm,"FAILURE");
  153.         return FAILURE;
  154.         }
  155.         SavSSP = SStPtr;
  156.         if (CMatch(&ChrMat) == FAILURE) {
  157.         DBGFEX(3,DbgFNm,"FAILURE");
  158.         return FAILURE;
  159.         }
  160.         *SamChr = ChrMat;
  161.         if (ChrMat) {
  162.         while (EBPtr2 <= RhtSid) {
  163.             SavEP2 = EBPtr2;
  164.             ++EBPtr2;
  165.             SStPtr = SavSSP;
  166.             if (CMatch(&ChrMat) == FAILURE) {
  167.             DBGFEX(3,DbgFNm,"FAILURE");
  168.             return FAILURE;
  169.             }
  170.             if (!ChrMat) {
  171.             EBPtr2 = SavEP2;
  172.             break;
  173.             }
  174.         }
  175.         }
  176. #if DEBUGGING
  177.         sprintf(DbgSBf,"SUCCESS, *SamChr = %s",(*SamChr)?"TRUE":"FALSE");
  178.         DbgFEx(3,DbgFNm,DbgSBf);
  179. #endif
  180.         return SUCCESS;
  181.  
  182.     case 'R':
  183.         *SamChr = Is_Alnum(*EBPtr2);
  184.         break;
  185.  
  186.     case 'S':
  187.         if ((*EBPtr2 != SPACE) && (*EBPtr2 != TABCHR)) {
  188.         *SamChr = FALSE;
  189.         } else {
  190.         *SamChr = TRUE;
  191.         while (EBPtr2 <= RhtSid) {
  192.             ++EBPtr2;
  193.             if ((*EBPtr2 != SPACE) && (*EBPtr2 != TABCHR)) {
  194.             EBPtr2--;
  195.             break;
  196.             }
  197.         }
  198.         }
  199.         break;
  200.  
  201.     case 'V':
  202.         *SamChr = Is_Lower(*EBPtr2);
  203.         break;
  204.  
  205.     case 'W':
  206.         *SamChr = Is_Upper(*EBPtr2);
  207.         break;
  208.  
  209.     case 'X':
  210.         *SamChr = TRUE;
  211.         break;
  212.  
  213.     case '<':
  214.         if (++SStPtr == SBfPtr) {
  215.         ErrMsg(ERR_ICE);
  216.         DBGFEX(3, DbgFNm,"FAILURE");
  217.         return FAILURE;
  218.         }
  219.         TmpChr = 0;
  220.         while (Is_Digit(*SStPtr)) {
  221.         TmpChr *= 8;
  222.         TmpChr += *SStPtr - '0';
  223.         if (TmpChr > 255) {
  224.             ErrMsg(ERR_ICE);
  225.             DBGFEX(3,DbgFNm,"FAILURE");
  226.             return FAILURE;
  227.         }
  228.         if (++SStPtr == SBfPtr) {
  229.             ErrMsg(ERR_ICE);
  230.             DBGFEX(3,DbgFNm,"FAILURE");
  231.             return FAILURE;
  232.         }
  233.         }
  234.         if (*SStPtr != '>') {
  235.         ErrMsg(ERR_ICE);
  236.         DBGFEX(3,DbgFNm,"FAILURE");
  237.         return FAILURE;
  238.         }
  239.         *SamChr = (*EBPtr2 == (unsigned char)TmpChr);
  240.         break;
  241.  
  242.     case '[':
  243.         if (++SStPtr == SBfPtr) {
  244.         ErrMsg(ERR_ICE);
  245.         DBGFEX(3,DbgFNm,"FAILURE");
  246.         return FAILURE;
  247.         }
  248.         while (*SStPtr != ']') {
  249.         if (*SStPtr == ',') {
  250.             if (++SStPtr == SBfPtr) {
  251.             ErrMsg(ERR_ICE);
  252.             DBGFEX(3,DbgFNm,"FAILURE");
  253.             return FAILURE;
  254.             }
  255.         } else {
  256.             if (CMatch(&ChrMat) == FAILURE) {
  257.             DBGFEX(3,DbgFNm,"FAILURE");
  258.             return FAILURE;
  259.             }
  260.             if (ChrMat) {
  261.             while (*SStPtr != ']') {
  262.                 if (++SStPtr == SBfPtr) {
  263.                 ErrMsg(ERR_ICE);
  264.                 DBGFEX(3,DbgFNm,"FAILURE");
  265.                 return FAILURE;
  266.                 }
  267.             }
  268.             *SamChr = TRUE;
  269. #if DEBUGGING
  270.             sprintf(DbgSBf,"SUCCESS, *SamChr = %s",
  271.                     (*SamChr) ? "TRUE" : "FALSE");
  272.             DbgFEx(3,DbgFNm,DbgSBf);
  273. #endif
  274.             return SUCCESS;
  275.             }
  276.             if (++SStPtr == SBfPtr) {
  277.             ErrMsg(ERR_ICE);
  278.             DBGFEX(3,DbgFNm,"FAILURE");
  279.             return FAILURE;
  280.             }
  281.         }
  282.         }
  283.         break;
  284.  
  285.     default:
  286.         ErrMsg(ERR_ICE);
  287.         DBGFEX(3,DbgFNm,"FAILURE");
  288.         return FAILURE;
  289.     } /* end of ^E switch */
  290.     break;
  291.  
  292.     default:
  293.     if (SMFlag == 0) {    /* if case independence */
  294.         OtCase = Is_Upper(*SStPtr) ? To_Lower(*SStPtr)
  295.                        : To_Upper(*SStPtr);
  296.         *SamChr = ((*EBPtr2 == *SStPtr) || (*EBPtr2 == OtCase));
  297.     } else {
  298.         *SamChr = (*EBPtr2 == *SStPtr);
  299.     }
  300.     } /* end of switch */
  301.  
  302. #if DEBUGGING
  303.     sprintf(DbgSBf,"SUCCESS, *SamChr = %s", (*SamChr) ? "TRUE" : "FALSE");
  304.     DbgFEx(3,DbgFNm,DbgSBf);
  305. #endif
  306.  
  307.     return SUCCESS;
  308. }
  309.